/*
 *  AntUI v1.0
 *  Copyright (C) 2011-2014
 *  www.AntUI.net
 *  AntUIPc@gmail.com
 *  power by kingark
*/
(function(_A, Win, Doc){
    
'use strict';
	
var Dmt = Doc.documentElement,
	head = tg('head')[0],
	links = tg('link'),
	js = tg('script'),
	//是否支持查询函数
	isQuery = !!Doc.querySelectorAll,
	empty = function(){},
	CLSN = 'className',
	OPAC = 'opacity',
	AUTO = 'auto',
	//节点的缓存数据
	nodeDataMap = {},
	//缓存私有属性
	privateAttrs = {},
	//动态加载时的回调函数队列
	usedStack = {},
	//任务队列
	taskStack = {},
	//缓存的数据
	datas = [],
	//标签声明的组件集合
	ants = {},
	//获取首位字符
	rf = /^\w+/,
	//检测微模版值格式
	rt = /{{(.+)}}/,
	//16位颜色值
	rco = /^#([0-9a-fA-f]{3}|[0-9a-fA-f]{6})$/,
	rrg = /^rgb\((\d+),(\d+),(\d+)\)/,
	rrga = /^rgba\((\d+),(\d+),(\d+),?.+\)/,
	ro = /opacity=.+/,
	theJS,
	//创建标签组件
	antag = Doc.createElement('ant');

/*-----  扩展  -----*/

//扩展函数
Function.prototype.expand = function(d, k){
	ip.call(this, d, typeof k == 'function' ? k() : k);
	return this;
};
Function.expand({
	//继承
	extend : function(parent, params, type){
		if(arguments.length && typeof parent == 'function'){
			var F = parent,
				p = {},
				_ = this;
			//过滤UI类中不能覆写的方法
			if(type == 'UI'){
				for(var i in params){
					if(i !== 'init' && i !== 'destroy' && i !== 'build' && i !== 'render'){
						p[i] = params[i];
					}
				}
			}else{
				p = params;
			}
			_.prototype = new F(p);
			_.prototype.constructor = _;
		}
	},
	//延时执行
	delay : function(time){
		setTimeout(this, time || 0);
	}
});
//扩展字符串（此扩展放到前面因为后面的主类有uri函数的调用）
String.expand({
	//去除首尾空格并返回
	trim : function(){
		return this.replace(/(^\s*)|(\s*$)/g, '');
	},
	//获取左边字符
	left : function(num){
		return this.substring(0, num);
	},
	//获取右边字符
	right : function(num){
		return this.substr(- num - 1, num);
	},
	//获取含有html标签里的纯文本
	text : function(){
		return this.replace(/<.*?>/g, '');
	},
	//转换为整型并返回
	int : function(radix){
		return parseInt(this, radix || 10);
	},
	//转换为浮点数并返回
	float : function(){
		return parseFloat(this);
	},
	//字符串作为URI组件进行编码
	uri : function(){
		return encodeURIComponent(this);
	},
	//转换键值字符串为对象并返回，为序列化的逆运算
	hash : function(){
		var o = {},
			a = this.split('&');
		eh(a, function(e){
			var p = e.split('=');
			o[p[0]] = p[1];
		});
		return o;
	},
	//统计字符串所占字符数，包括汉字
	size : function(){
		return this.replace(/[^\x00-\xff]/g, '00').length;
	},
	//转换为货币格式
	money : function(){
		return this.replace(/\B(?=(\d{3})+$)/g,',');
	},
	//循环输出
	repeat : function(n){
		return en(this, n);
	},
	//转义html
	escapeHTML : function(){
		return this.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;').replace(/'/g, '&#39;');
	},
	//反转义html
	unescapeHTML : function(){
		return this.replace(/&amp;/g, '&').replace(/&lt;/g, '<').replace(/&gt;/g, '>').replace(/&quot;/g, '"').replace(/&#39;/g, '\'').replace(/&#([\d]+);/g, function(m, n){
			return String.fromCharCode((n, 10).int());
		});
	},
	//RGB颜色转换为16进制
	colorHex : function(){
		var _ = dh(this.toLowerCase()),
			c = _.match(rrg);
		if(c && c.length){
			c.shift();
			var s = '';
			eh(c, function(e, i){
				if(i < 3){
					var ei = e.int();
					s += ei ? ei.toString(16) : '00';
				}
			});
			return '#' + s;
		}else{
			return _;
		}
	},
	//16进制颜色转为RGB格式
	colorRgb : function(){
		var c = dh(this.toLowerCase()),
			l = c.length;
		if(c && rco.test(c)){
			var s = [],
				c = c.replace('#', '');
			//颜色值简写
			if(l === 4){
				eh(c.split(''), function(e){
					s.push(('0x' + e + e).int(16));
				});
			}else{
				for(var i = 0; i < 6; i += 2){
					s.push(('0x' + c.slice(i, i + 2)).int(16));
				}
			}
			return dh('rgb(' + s.join(',') + ')');
		}else{
			return c;
		}
	}
});


//扩展ECMA5标准中的数组方法
if(Doc.all && ![].filter){
	Array.expand({
		//查找元素出现的第一个位置
		indexOf : function(ele){
			var n = -1;
			eh(this, function(e, i){
				if(e == ele){
					n = i;
					return false;
				}
			});
			return n;
		},
		//返回一个指定的字符串值最后出现的位置，在一个字符串中的指定位置从后向前搜索
		lastIndexOf : function(ele) {
			var i = this.length;
			while(i--){
				if (this[i] === ele){
					return i;
				}
			}
			return -1;
		},
		//检查数组元素是否都符合某个条件，只要有一个不符合返回false，否则返回true
		every : function(callback) {
			var _ = this,
				i = _.length;
			while (i--) {
				if(i in _ && !callback.call(_, _[i], i)){
					return false;
				}
			}
			return true;
		},
		//检查数组中元素是否符合某个条件，只要有一个符合返回true，否则返回false
		some : function(callback) {
			var _ = this,
				i = this.length;
			while (i--) {
				if(i in _ && callback.call(_, _[i], i)){
					return true;
				}
			}
			return false;
		},
		//在数组中的每个项上运行一个函数，并将函数返回真值的项作为数组返回   
		filter : function(callback) {
			var _ = this,
				ar = [],
				arLength = 0;
			eh(_, function(e, i){
				if(callback.call(_, e, i, _)){
					ar[arLength++] = e;
				}
			});
			return ar;
		},
		//在数组中的每个项上运行一个函数，并将全部结果作为数组返回
		map : function(callback) {
			var _ = this,
				res = [];
			eh(_, function(e,i){
				res[i] = callback.call(_, e, i, _); 
			}); 
			return res;
		}
	});
}
//扩展数组
Array.expand({
	//遍历，并返回数组本身
	each : function(callback){
		var _ = this;
		_.forEach ? _.forEach(callback) : eh(_, callback);
		return _;
	},
	//倒序遍历
	desc : function(callback){
		var _ = this;
		for(var i = _.length - 1; i >= 0; i --){
			callback.call(_, _[i], i);
		}
		return _;
	},
	//返回复制的新数组
	copy : function(){
		return this.slice(0);
	},
	//返回尾元素
	last : function(){
		return this[this.length - 1];
	},
	//返回最小值
	min : function(){
		return Math.min.apply(Math, this);
	},
	//返回最大值
	max : function(){
		return Math.max.apply(Math, this);
	},
	//返回总和
	sum : function(){
		var s = 0;
		eh(this, function(e, i){
			s += A.isNum(e) ? e : parseFloat(e) || 0;
		});
		return s;
	},
	//返回平均数
	average : function(){
		return this.sum() / this.length;
	},
	//连接数组或对象，适合将类似DOM序列等集合元素添加到数组中
	merge : function(a){
		if(a && a.length){
			if(a.concat){
				return a.concat(this);
			}else{
				var ar = this.copy();
				eh(a, function(e){
					ar.push(e);
				});
				return ar;
			}
		}else{
			return this;
		}
	},
	//获取与另一个数组的交集，返回一个新数组
	intersect : function(ar){
		if(ar && ar.length){
			return this.filter(function(e){
				return ar.indexOf(e) > -1;
			});
		}
	},
	//获取另一个数组的差集，返回一个新数组
	diff : function(ar){
		var o = [],
			_ = this;
		if(ar && ar.length){
			eh(_, function(e){
				!hv(ar, e) && o.push(e);
			});
			eh(ar, function(e){
				!hv(_, e) && o.push(e);
			});
		}
		return o;
	},
	//去除数组元素的重复值并返回去除后的数组
	unique : function(){
		var _ = this;
		_.sort();
		var re = [_[0]];
		eh(_, function(e, i){
			if(e !== re.last()){
				re.push(e);
			}
		});
		return re;
	},
	//将a2元素一一对应变本数组的值，并返回该对象
	mix : function(a2){
		var _ = this;
		if(a2 && _.length == a2.length){
			var o = {};
			eh(_, function(e,i){
				o[e] = a2[i];
			});
			return o;
		}
	},
	//检测数组是否包含元素key，返回boolean值
	have : function(key){
		return hv(this, key);
	},
	//返回随机的一个数组元素
	random : function(){
		return this[(Math.random() * this.length).round()];
	},
	
	//将数组中元素key擦除，并返回擦除后的数组，global为布尔类型，代表是否全局删除，默认为false
	remove : function(key, global){
		var _ = this,
			isFn = A.isFn(key);
		eh(_, function(e, i){
			if(isFn ? key.call(_, e, i) : (e === key)){
				_.splice(i, 1);
				if(!global) return false;
			}
		});
		return _;
	},
	//获取符合一定条件的元素
	get : function(fn){
		var _ = this,
			res = [];
		eh(_, function(e, i){
			var o = fn.call(_, e, i, _);
			if(o){
				res.push(e);
			}
		});
		return res;
	}
});

//扩展数值
'abs acos asin atan ceil cos exp floor log round sin sqrt tan'.split(' ').each(function(e, i){
	Number.prototype[e] = function(){
		return Math[e](this);
	}
});
//自动补全位数
Number.prototype.fix = function(len){
	return (this / Math.pow(10, len)).toFixed(len).substr(2);
};
//返回min到max之间的一个随机数
Number.random = function(min, max){
	return Math.random() * (max - min + 1) + min;
};


//查找并标识此库文件
if(Doc.currentScript){
	theJS =  Doc.currentScript;
}else if(Doc.all){
	for(var i = 0, el; el = js[i++];){
		if(el.readyState === 'interactive') {
			theJS = el;
		}
	}
}else{
	theJS = js[js.length - 1];
}

/*-----  主类  -----*/
var A = {
	//版本号
	version : '1.0',
	//模块配置，与add方法配合使用
	config : {
		//保存主文件的路径，以便加载模块时查找相对主文件的路径，默认为空，表示和页面在同一目录下
		'path' : '',
		//是否缓存
		'cache' : true,
		//保存组件的默认主题名称
		'theme' : 'Default'
	},
	//客户端检测
	UA : function() {
		var bs = navigator.userAgent.toLowerCase();
		//检测
		function c(r) {
			return hv(bs, r);
		}
		var op   = c('opera'),
			sa   = c('safari'),
			ch   = c('chrome') && sa,
			ff   = c('gecko') && !c('webkit'),
			ie   = !!Doc.all,
			ie6  = ie && !Win.XMLHttpRequest,
			ie7  = ie && c('msie 7'),
			ie8  = ie && c('msie 8'),
			ie9  = Doc.documentMode == 9,
			ie10 = Doc.documentMode == 10;
		A.UA = function(){
			return {'OP' : op, 'SA' : sa, 'CH' : ch, 'FF' : ff, 'IE' : ie, 'IE6' : ie6, 'IE7' : ie7, 'IE8' : ie8, 'IE9' : ie9, 'IE10' : ie10}
		};
		return A.UA();
	},
	//创建类
	create : function(){
		return function() {
			var _ = this;
			_.init && _.init.apply(_, arguments);
		}
	},
	//Dom构建完毕时执行
	ready : function(callback){
		//新建任务队列
		A.task.push('Ready', callback);
		//标准浏览器下
		if (Doc.addEventListener){
			Doc.addEventListener('DOMContentLoaded', function(){
				doit();
			}, false);
		//ie下
		}else{
			var done = false,
				init = function () {
					if (!done) {
						done = true;
						doit();
					}
				};
			(function(){
				try {
					Doc.doScroll('left');
				} catch (e) {
					arguments.callee.delay(50);
					return;
				}
				init();
			})();
			Doc.onreadystatechange = function() {
				if (Doc.readyState == 'complete') {
					Doc.onreadystatechange = null;
					init();
				}
			}
		}
		//执行队列
		function doit(){
			A.task.start('Ready');
		};
		return this;
	},
	//序列化表单数据为键值字符串
	serialize : function(fid){
		var form = Doc.getElementById(fid),
			parts = [];
		eh(form.elements, function(e){
			switch(e.type){
			case 'select-one':
			case 'select-multiple':
				eh(e, function(o){
					if(o.selected){
						var optValue = o.hasAttribue ? (o.hasAttribute('value') ? o.value : o.text) : (o.attributes['value'] ? o.value : o.text);
						parts.push(e.name.uri() + '=' + optValue.uri());
					}
				});
				break;
			case undefined:
			case 'file':
			case 'submit':
			case 'reset':
			case 'button':
			break;
			case 'radio':
			case 'checkbox':
				if(!e.checked){
					break;
				};
			default : 
				parts.push(e.name.uri() + '=' + e.value.uri());
			}
		});
		return parts.join('&');
	},
	//缓存对象的堆栈，除内置操作方法外，新增类按类分组，如：A.stack.queue{ 'Fx' : [], 'UI' : [], 'Event' : []}
	stack : {
		//加入任务队列
		add : function(type, o){
			A.stack.queue[type].push({'target' : o, 'id' : id(type)});
			return this;
		},
		//剔除队列中元素
		remove : function(type, o){
			A.stack.queue[type].remove(function(e){
				return e.target == o;
			});
			return this;
		},
		//存储队列列表，集合类型，格式如：{ type : [类实例列表]} ，类实例列表为数组类型
		queue : {}
	},
	//任务队列管理
	task : {
		//添加任务
		push : function(id, fn){
			taskStack[id] = taskStack[id] || [];
			taskStack[id].push(fn);
			return this;
		},
		//开始执行
		start : function(id){
			var _t = taskStack[id];
			while(_t.length){
				if(A.isFn(_t[0])){
					_t[0].call(_t);
				}
				_t.splice(0, 1);
			}
			return this;
		}
	},
	//缓存数据
	data : {
		//添加缓存数据
		add : function(name, val){
			datas.push({'target' : name, 'value' : val});
			return this;
		},
		//获取数据
		get : function(name){
			var o = datas.get(function(e){
				return e.target == name;
			});
			return o[0] ? o[0].value : '';
		},
		//删除数据
		remove : function(name){
			datas.remove(function(e){
				return e.target == name;
			});
			return this;
		}
	},
	//cookie操作对象
	cookie : {
		//设置cookies，name为设置cookie的名称，value对对应的值
		add : function(name, value, day){
			//此 cookie 将默认被保存 30 天
			var DAYS = day || 30,
				ex = new Date();
			ex.setTime(ex.getTime() + DAYS * 24 * 60 * 60 * 1000);
			Doc.cookie = name + '='+ escape(value) + ';expires=' + ex.toGMTString();
			return this;
		},
		//获取cookie
		get : function(name){
			var arr = Doc.cookie.match(new RegExp('(^| )' + name + '=([^;]*)(;|$)'));
			return arr != null ? unescape(arr[2]) : null;
		},
		//删除cookie
		remove : function(name){
			var ex = new Date(),
				cval = A.cookie.get(name);
			ex.setTime(ex.getTime() - 1);
			cval != null && (Doc.cookie = name + '=' + cval + ';expires=' + ex.toGMTString());
			return this;
		}
	},
	//事件操作对象
	event : {
		//添加事件
		add : function(target, type, handler, once, index){
			//为每一个绑定事件的对象创建一个Event实例
			new A.Event(target, type, handler, once, index);
			return this;
		},
		//移除事件
		remove : function(target, type){
			//遍历事件队列查找当前对象
			A.stack.queue.Event.each(function(o){
				var tg = o.target;
				tg.target == target && tg.type == type && tg.destroy();
			});
			return this;
		}
	},
	//创建节点
	build : function(tags, isStr){
		return A.Tpl.create({ tpl : tags, str : isStr}).parse();
	},
	//加载JS
	inc : function(url, callback, follow, isCache){
		//检测文档中是否已经存在该文件
		var _ = this,
			_url = escape(url),
			isCache  = A.isNull(isCache) ? this.config.cache : isCache,
			//判断页面中是否存在该文件
			n = ma(tg('script')).get(function(e){
				return hv(e.src, url);
			});
		//
		if(!n.length){
			var _js = Doc.createElement('script');
			_js.src = url + (isCache ? '' : (hv(url, '?') ? '&' : '?') + '_t=' + rd());
			
			//加载完成
			if(Doc.all) {
				_js.onreadystatechange = function() {
					if(_js.readyState == 'loaded' || _js.readyState == 'complete'){
						doit();
					}
				}
			}else{
				_js.onload = doit;
			}
			//如果未指定js的插入位置则默认插入到文档的尾部
			follow ? theJS.parentNode.insertBefore(_js, theJS.nextSibling) : Doc.body.appendChild(_js);
		}
		//新建任务队列
		A.task.push('Inc', callback);
		//执行队列
		function doit(){
			A.task.start('Inc');
		}
		return _;
	},
	//加载外部样式表
	link : function(url){
		dc(url);
		return this;
	},
	//加载xml
	getXML : function(url, callback){
		var _ = this,
			xml;
		//兼容IE6
		if(Win.ActiveXObject){   
			xml = new ActiveXObject('Microsoft.XMLDOM');
			//ie下同步加载
			xml.async = false;
			xml.load(url);
			callback.call(_, xml);
		}else if(Win.DOMParser){
			//用ajax方式加载xml
			A.get(url, function(e){
				xml = new Win.DOMParser().parseFromString(e, 'text/xml');
				callback.call(_, xml);
			});
		}
		return _;
	},
	//加载JSON
	getJSON : function(url, callback){
		return A.get(url, function(e){
			//由JSON类解析
			callback.call(A, new A.JSON().parse(e));
		});
	},
	//ajax请求快捷方法
	get : function(url, callback){
		new A.IO().request(url, callback);
		return this;
	},
	//ajax请求快捷方法
	post : function(url, data, callback){
		var db = { 'method' : 'post' },
			isfn = A.isFn(data);
		if(arguments.length > 1 && !isfn){
			db.data = data;
		}
		new A.IO(db).request(url, isfn ? data : callback);
		return this;
	},
	//添加模块处理
	add : function(name, prototype, conf){
		var _ = this;
		
		//model用于存储模块名称
		prototype.model = name;
		
		//创建新类，绑定到主库
		_[name] = _.create();
		
		//创建类队列
		A.stack.queue[name] = [];
		
		//给类实例增加expand扩展方法
		var cu = _[name];
		
		//无new创建类对象方法
		cu.create = function(params){
			return new cu(params);
		};
		
		//设置属性
		if(!prototype.set){
			prototype.set = function(name, val, pvt){
				var len = arguments.length,
					__ = this;
				if(len > 1 && A.isStr(name)){
					//给每个类对象加一个uid
					if(!__._uuid){
						__._uuid = rd();
						//私有变量缓存
						privateAttrs[__._uuid] = {};
					}
					if(!pvt){
						__[name] = val;
					}else{
						privateAttrs[__._uuid][name.indexOf('_') == 0 ? name : '_' + name] = val;
					}
				}else
				if(len == 1 && ob(name)){
					for(var i in name){
						__.set(i, name[i]);
					}
				}
				return __;
			};
		}
		//获取属性
		if(!prototype.get){
			//获取属性
			prototype.get = function(name, pvt){
				var __ = this,
					_uuid = __._uuid;
				return !pvt ? __[name] : _uuid ? privateAttrs[_uuid][name] : null;
			};
		}
		
		//如果有继承
		if(conf && conf.extend){
			var ext = conf.extend;
			//集成父类属性
			cu.extend(_[ext], prototype, ext);
			//重置model
			cu.prototype.model = name;
		}else{
			cu.prototype = prototype;
		}
		
		//写入配置文件
		var config = _.config;
		//初始化参数
		config[name] = {
			'url' : config.path + name + '/' + name + '.js', 'name' : name, 'css' : '', 'extend' : '', 'use' : ''
		};
		//配置
		if(conf){
			if(conf.css){
				conf.css = 'Themes/' + config.theme + '/css/' + conf.css;
			}
			_r(conf, config[name]);
		}
		return _;
	},
	//调用模块
	use : function(name, complete){
		var _ = this,
			complete = complete || empty,
			conf = _.config;
			
		//如果是多重调用
		if(hv(name,',')){
			var list = name.split(','),
				n = 0;
			//循环完成后的回调没有参数
			list.desc(function(e){
				var obj = e.trim();
				_.inc(conf.path + obj + '/' + obj + '.js', function(){
					n ++;
					var cuconf = conf[obj];
					//每加载完成一个模块就检测一下该模块的依赖关系
					if(cuconf.use){
						_.use(cuconf.use, function(){
							complete.call(_);
						});
					}
					//模块加载完成后添加样式表 
					cuconf.css && dc(A.config.path + cuconf.css);
					if(n == list.length){
						complete.call(_);
					}
				}, true);
			});
		}else{
			//单个模块调用，回调中参数为模块的引用
			var cu = _[name];
				
			//如果已经存在该组件就直接调用回调
			if(cu){
				complete.call(_, cu);
				var _conf = conf[name];
				//检测是否有附加样式表
				_conf.css && dc(A.config.path + _conf.css);
			}else{
				_.inc(conf.path + name + '/' + name + '.js', function(){
					var cuconf = conf[name];
					//如果有依赖的模块
					if(cuconf && cuconf.use){
						_.use(cuconf.use, function(){
							complete.call(_, _[name]);
						});
					}else{
						complete.call(_, _[name]);
					}
					//检测是否有附加样式表
					cuconf.css && dc(A.config.path + cuconf.css);
				}, true);
			}
		}
		return _;
	},
	//获取由id查询返回的节点，str为要查询的元素id或者单个节点
	one : function(str){
		var o;
		if(str){
			//如果是id名称
			if(A.isStr(str)){
				o = nd(Doc.getElementById(str));
			}else 
			//如果是单节点
			if(A.isEle(str)){
				o = nd(mr(str));
			}else 
			if(iw(str)){
				o = nd(str.parent);
			}
			return o;
		}else{
			return nd();
		}
	},
	//获取由tag名查询返回的节点
	tag : function(tag){
		var o;
		if(tag){
			//如果是tag名称
			if(A.isStr(tag)){
				o = nd(tg(tag));
			}else 
			//如果是节点序列
			if(tag.length){
				o = nd(tag);
			}else 
			//如果是window
			if(iw(str)){
				o = nd(str.parent);
			}
			return o;
		}else{
			return nd();
		}
	},
	//获取全部节点
	all : function(str){
		var o;
		if(str){
			//如果是查询字符串
			if(A.isStr(str)){
				o = nd(isQuery ? Doc.querySelectorAll(str) : str);
			}else
			//如果是节点或者节点序列
			if(A.isEle(str) || str.length){
				o = nd(str);
			}
			return o;
		}else{
			return nd();
		}
	},
	//判断数据类型
	is : function(o, ty){
		switch(ty){
			case 'Str':
				return typeof o === 'string';
			case 'Num':
				return typeof o === 'number';
			case 'Fn':
				return typeof o === 'function';
			case 'Null':
				return typeof o === 'undefined' || o == null;
			case 'Ele':
				//如果是window 或 document
				if(iw(o) || o == Doc){
					return true;
				}else{
					return !o.length && !!o.nodeType && !!o.nodeName;
				}
			case 'Array':
				return Object.prototype.toString.call(o) === '[object Array]' 
					? true 
					: o.callee || (!A.isNull(o.item) && !o.nodeType && !o.alert) ? true : false;
			case 'Node':
				return !!o.model && o.model == 'Node';
		}
	},
	//生成随机码
	random : function(len, isNum){
		return rd(len, isNum);
	},
	//扫描组件
	scan : function(){
		var _ = this;
		eh(tg('ant'), function(e){
			//隐藏标签
			e.style.display = 'none';
			//
			var t = e.getAttribute('type'),
				init = e.getAttribute('init'),
				m = _[t];
			//如果已经加载了该模块文件
			if(m){
				b(m);
			}else{
				_.use(t, function(){
					b(_[t]);
				});	
			}
			//构建组件
			function b(m){
				var params = {};
				eh(e.attributes, function(o){
					var k = o.nodeName;
					//过滤属性
					if(k != 'type' && k != 'init' && k != 'style'){
						var r = new RegExp('\{(.*?)\}', 'g'),
							v = o.nodeValue;
						//处理变量
						if(r.test(v)){
							v = v.replace(r, function(m, n){
								return n;
							});
							v = eval('('+ v +')');
						}
						params[k] = v;
					}
				});
				//重置布局
				if(e.innerHTML){
					params.content = e.innerHTML;
				}
				//实例化方式
				params.initType = 'tag';
				//实例化
				var a = A[t].create(params);
				
				//分析启动函数
				if(init){
					//如果集成UI类，渲染目标则为当前标签位置
					if(a.render){
						//临时记录标签位置
						a.set('tag', e, true);
					}else{
						//非UI类删除标签
						e.parentNode.removeChild(e);
					}
					a[init]();
				}
				//加入集合
				ants[e.getAttribute('id') || 'Ant' + A.random(8)] = a;
			}
		});
		return _;
	},
	//获取组件
	getComponent : function(id){
		if(id && typeof id == 'string'){
			return ants[id];
		}
	}
};
//扩展数据类型判断便捷方法
eh('Str Num Fn Null Ele Array Node'.split(' '), function(e){
	A['is' + e] = function(o){
		return A.is(o, e);
	};
});
//快捷引用
var isStr = A.isStr,
	isNum = A.isNum,
	isEle = A.isEle,
	isFn = A.isFn,
	isNode = A.isNode,
	isIE6 = A.UA().IE6;

//查找并设置主文件路径
if(hv(theJS.src, '/')){
	A.config.path = theJS.src.split('/').slice(0, -1).join('/') + '/';
}

/*----添加哈希表类-----*/
A.add('Map', {
	//初始化
	init : function(obj){
		this.hash = obj || {};
		return this;
	},
	//析构函数
	destroy : function(){
		//从队列中删除
		A.stack.remove('Map', this);
	},
	//遍历
	each : function(callback){
		var _ = this;
		for(var i in _.hash){
			callback.call(this, i, _.hash[i]);
		}
		return _;
	},
	//返回对象元素个数
	size : function(){
		var n = 0;
		for(var i in this.hash){
			n ++;
		}
		return n;
	},
	//序列化对象为键值字符串
	parse : function(){
		var s = [],
			tg = this.hash;
		for(var i in tg) {
			s.push(i + '=' + tg[i]);
		}
		return s.join('&');
	},
	//增加元素
	add : function(k, v){
		var _ = this,
			len = arguments.length;
		//参数为两个表示增加一个元素
		if(len == 2 && isStr(k)){
			_.hash[k] = v;
		}else 
		//参数为一个表示增加元素集合
		if(len == 1 && ob(o)){
			for(var i in k){
				_.add(i, k[i]);
			}
		}
		return _;
	},
	//将对象中元素key擦除，并返回擦除后的对象
	remove : function(key){
		var _ = this;
		if(isStr(key)){
			//如果是多个元素
			if(hv(key, ',')){
				key.split(',').each(function(e){
					_.remove(e.trim());
				});
			}
			//删除一个元素
			else{
				delete this.hash[key];
			}
		}
		return this;
	},
	//返回值为val元素
	keyOf : function(val){
		return kh(this, val);
	},
	//是否包含值为val的元素
	have : function(val){
		return kh(this, val, true);
	},
	//合并哈希表
	comb : function(hash, isRe){
		var _ = this,
			tg = _.hash,
			hash = hash.model && hash.model == 'Map' ? hash.hash : hash;
		for(var i in hash){
			tg[i] = A.isNull(tg[i]) ? hash[i] : isRe ? hash[i] : tg[i];
		}
		return _;
	}
});

/*----添加节点类-----*/
A.add('Node', {
	//存储查询节点的数组
	$ : [],
	//存储查询字符串
	query : '',
	//构造函数
	init : function(str){
		var _ = this;
		if(str){
			//缓存查询字符串
			_.query = isStr(str) ? str : '';
			//
			_.$ = isQuery ? ma(sl(str)) : sl(str);
		}
		//存储节点上的动画对象
		_.animate = [];
		//加入队列
		A.stack.add('Node', _);
	},
	//析构函数
	destroy : function(){
		//从队列中删除
		A.stack.remove('Node', this);
	},
	//查询子节点
	find : function(str){
		return nd(fd(this.$, str));
	},
	//过滤节点
	filter : function(str){
		return nd(fit(this.$, str, 'tag'));
	},
	//返回查询到节点数组的长度
	size : function(){
		return this.$.length;
	},
	//循环节点数组
	each : function(ar){
		eh(this.$, ar);
		return this;
	},
	//创建一个该节点对象的副本
	clone : function(){
		return nd(this.$);
	},
	//返回索引节点
	item : function(n){
		return nd(this.$[n]);
	},
	//返回查询结果的原生节点元素
	list : function(i){
		return this.$[i];
	},
	//截取节点数组
	slice : function(n1, n2){
		return nd(this.$.slice(n1, n2));
	},
	//获取查询的首个节点
	first : function(){
		return nd(this.$[0]);
	},
	//获取查询的最后一个节点
	last : function(){
		return nd(this.$.last());
	},
	//查找返回索引
	at : function(c){
		var li = this.$;
		if(li.length){
			return li.indexOf(isNode(c) ? c.$[0] : c);
		}
		return this;
	},
	//删除元素
	remove : function(){
		return this.offAll().each(function(e){
			e.parentNode.removeChild(e);
		});
	},
	//清空子节点
	clear : function(){
		return this.offAll().each(function(e){
			e.innerHTML = '';
		});
	},
	//筛选元素的兄弟节点，不包括当前节点，s为节点过滤字符串，可选
	siblings : function(s){
		var _o = [];
		this.each(function(oo){
			eh(oo.parentNode.children, function(e){
				e != oo && _o.push(e);
			});
		});
		return nd(isStr(s) ? fit(_o, s) : _o);
	},
	//筛选子节点，s为筛选字符串，可附带标签名与样式名，如div.head
	son : function(s){
		return nd(fis(this.$, s));
	},
	//获取元素父节点
	parent : function(){
		return dr(this, 'parentNode', true);
	},
	//查找元素所有父节点，s为筛选字符串
	parents : function(s){
		return dr(this, 'parentNode', false, s.toLowerCase());
	},
	//获取元素后面的节点
	next : function(){
		return dr(this, 'nextSibling', true);
	},
	//筛选元素后面的节点序列
	nextAll : function(s){
		return dr(this, 'nextSibling', false, s);
	},
	//获取元素前面的节点
	prev : function(){
		return dr(this, 'previousSibling', true);
	},
	//筛选元素前面的节点序列
	prevAll : function(s){
		return dr(this, 'previousSibling', false, s);
	},
	//过滤偶数元素
	even : function(){
		return eo(this, true);
	},
	//过滤奇数元素
	odd : function(){
		return eo(this);
	},
	//获取元算顶级节点
	top : function(){
		return dr(this, 'parentNode', false);
	},
	//操作文本代码
	html : function(val){
		return st(this.$, 'innerHTML', ttp(val, true), this);
	},
	//操作纯代码
	text : function(val){
		return st(this.$, A.UA().FF ? 'textContent' : 'innerText', val, this);
	},
	//操作值
	val : function(val){
		return st(this.$, 'value', val, this);
	},
	//设置属性
	set : function(c, v){
		var cc = {};
		arguments.length == 2 && isStr(c) ? cc[c] = v : cc = c;
		return this.each(function(e){
			ar(cc, e);
		});
	},
	//获取属性
	get : function(c){
		var $ = this.$;
		if($.length && $[0]){
			return $[0].getAttribute(c);
		}
	},
	//删除属性
	del : function(c){
		if(isStr(c)){
			return this.each(function(o){
				o.removeAttribute(c);
			});
		}
	},
	//缓存数据
	data : function(name, data){
		var _ = this,
			arglen = arguments.length,
			_k = 'data-cache';
		//参数为一个
		if(arglen == 1){
			//获取数据值
			if(isStr(name)){
				var _f = _.$[0],
					//如果非节点则转化为body
					cu = _f == Doc || iw(_f) ? Doc.body : _f,
					_data = nodeDataMap[cu.getAttribute(_k)];
				//如果为节点元素
				return cu && cu.getAttribute && _data ? _data[name] : '';
			}else
			//设置一个数据序列
			if(ob(name)){
				for(var i in name){
					_.data(i, name[i]);
				}
			}
		}else
		//参数为两个时设置值
		if(arglen == 2){
			_.each(function(e, i){
				//如果非节点则转化为body
				if(e == Doc || iw(e)){
					e = Doc.body;
				}
				if(e.setAttribute){
					var cache = e.getAttribute(_k),
						_data = nodeDataMap[cache];
					//如果有缓存对象
					if(cache && _data){
						_data[name] = data;
					}else{
						var rn = rd(),
							_data = nodeDataMap[rn] = {};
						//绑定dom
						e.setAttribute(_k, rn);
						_data[name] = data;
					}
				}
			});
			return _;
		}
	},
	//删除数据
	removeData : function(name){
		var _k = 'data-cache';
		return this.each(function(e){
			if(isStr(name)){
				var _data = nodeDataMap[e.getAttribute(_k)];
				if(_data && _data[name]){
					delete _data[name];
				}
			}
		});
	},
	//外层包裹
	wrap : function(e){
		//如果是String类型则生成包裹元素
		var is = isStr(e),
			_i = this.$.length == 1,
			e = is ? mr(A.build(e)) : tr(e);
		return this.each(function(o){
			var _o = _i ? e[0] : e[0].cloneNode(true);
			o.parentNode.insertBefore(_o, o);
			_o.appendChild(o);
		});
	},
	//里层包裹
	wrapInner : function(e){
		//如果是String类型则生成包裹元素
		var is = isStr(e),
			_i = this.$.length == 1,
			e = is ? mr(A.build(e)) : tr(e);
		return this.each(function(o){
			var _o = _i ? e[0] : e[0].cloneNode(true),
				cd = o.childNodes;
			while(cd[0]){
				_o.appendChild(cd[0]);
			}
			o.appendChild(_o);
		});
	},
	//替换节点
	replace : function(e){
		//如果是String类型则生成包裹元素
		var is = isStr(e),
			_i = this.$.length == 1,
			e = is ? (rt.test(e) ? mr(ttp(e)) : e) : tr(e);
		return this.each(function(o){
			var parent = o.parentNode;
			if(is && isStr(e)){
				parent.replaceChild(Doc.createTextNode(e), o);
			}else{
				//如果多节点
				if(e.length > 1){
					//插入节点前
					eh(e, function(oo){
						parent.insertBefore(_i ? e[0] : oo.cloneNode(true), o);
					});
					//删除替换节点
					parent.removeChild(o);
				}else{
					parent.replaceChild(_i ? e[0] : e[0].cloneNode(true), o);
				}
			}
		});
	},
	//从后面插入元素
	append : function(e){
		//添加的节点是否为文本
		var is = isStr(e),
			_i = this.$.length == 1,
			e = is ? (rt.test(e) ? mr(ttp(e)) : e) : tr(e);
		return this.each(function(o, i){
			if(is && isStr(e)){
				o.appendChild(Doc.createTextNode(e));
			}else{
				eh(e, function(oo){
					o.appendChild(_i ? e[0] : oo.cloneNode(true));
				});
			}
		});
	},
	//插入到文档子元素之后
	appendTo : function(e){
		var _ = this,
			$ = _.$;
		//如果本对象有节点
		if($.length && $[0] && $[0].nodeType == 1){
			nd(isStr(e) ? e : tr(e)).append(_);
		}
		return _;
	},
	//从前面插入元素
	insert : function(e){
		var is = isStr(e),
			e = is ? (rt.test(e) ? mr(ttp(e)) : e) : tr(e),
			_i = this.$.length == 1;
		return this.each(function(o){
			var _fir = o.childNodes[0];
			if(is && isStr(e)){
				o.insertBefore(Doc.createTextNode(e), _fir);
			}else{
				eh(e, function(oo){
					o.insertBefore(_i ? e[0] : oo.cloneNode(true), _fir)
				});
			}
		});
	},
	//插入到指定文档子元素之前
	insertTo : function(e){
		var _ = this,
			$ = _.$;
		//如果本对象有节点
		if($.length && $[0] && $[0].nodeType == 1){
			nd(isStr(e) ? e : tr(e)).insert(_);
		}
		return _;
	},
	//插入到元素前面
	before : function(e){
		//添加的节点是否为文本
		var is = isStr(e),
			_i = this.$.length == 1,
			e = is ? (rt.test(e) ? mr(ttp(e)) : e) : tr(e);
		return this.each(function(o, i){
			var parent = o.parentNode;
			if(is && isStr(e)){
				parent.insertBefore(Doc.createTextNode(e), o);
			}else{
				eh(e, function(oo){
					parent.insertBefore(_i ? e[0] : oo.cloneNode(true), o)
				});
			}
		});
	},
	//插入到元素后面
	after : function(e){
		var is = isStr(e),
			_i = this.$.length == 1,
			e = is ? (rt.test(e) ? mr(ttp(e)) : e) : tr(e);
		return this.each(function(o){
			var _n = o.nextSibling,
				parent = o.parentNode;
			if(is && isStr(e)){
				parent.insertBefore(Doc.createTextNode(e), _n);
			}else{
				eh(e, function(oo){
					parent.insertBefore(_i ? e[0] : oo.cloneNode(true), _n)
				});
			}
		});
	},
	//操作宽度
	width : function(val, time){
		return time && isNum(time) ? this.fx({'width': val}, time) : wh(this.$, 'width', val, this);
	},
	//操作高度
	height : function(val, time){
		return  time && isNum(time) ? this.fx({'height': val}, time) : wh(this.$, 'height', val, this);
	},
	//获取外部总宽度
	outerWidth : function(){
		var $ = this.$;
		return $[0] ? $[0].offsetWidth : null;
	},
	//获取外部总高度
	outerHeight : function(){
		var $ = this.$;
		return $[0] ? $[0].offsetHeight : null;
	},
	//显示
	show : function(){
		return dp(this.$, true, this);
	},
	//隐藏
	hide : function(){
		return dp(this.$, false, this);
	},
	//操作样式
	css : function(style, val){
		var c = {};
		arguments.length == 2 && isStr(style) ? c[style] = val : c = style;
		return cs(this.$, c, this);
	},
	//添加样式
	addClass : function(c){
		return this.each(function(e){
			ac(e, c);
		});
	},
	//删除样式
	removeClass : function(c){
		return this.each(function(e){
			rc(e, c);
		});
	},
	//替换样式
	replaceClass : function(c1, c2){
		return this.each(function(e){
			e[CLSN] = (' ' + e[CLSN] + ' ').replace(' ' + c1 + ' ', c2);
		});
	},
	//判断是否包含某样式名
	hasClass : function(c){
		var $ = this.$;
		return $[0] ? hs($[0], c) : null;
	},
	//鼠标经过切换样式
	hoverClass : function(c){
		return this.on('mouseover mouseout', function(e){
			var e = e.target;
			hs(e, c) ? rc(e, c) : ac(e, c);
		});
	},
	//切换样式
	toggleClass : function(evt, c){
		//如果参数为1个且为字符类型
		if(arguments.length == 1 && isStr(evt)){
			return this.each(function(e){
				hs(e, evt) ? rc(e, evt) : ac(e, evt);
			});
		}else{
			//如果指定切换的事件
			return this.on(evt, function(e){
				e = e.target;
				hs(e, c) ? rc(e, c) : ac(e, c);
			});
		}
	},
	//获取元素的绝对位置
	offset : function (){
		var $ = this.$;
		return $[0] ? po($[0]) : null;
	},
	//添加侦听
	on : function(type, handler, once){
		var _ = this;
		//如果是事件集合
		if(arguments.length == 1 && ob(type)){
			for(var j in type){
				_.on(j, type[j]);
			}
		}else 
		//如果是单个事件名称
		if(isStr(type) && type.length){
			if(hv(type, ' ')){
				eh(type.split(' '), function(e){
					_.on(e, handler, once);
				});
			}else{
				return _.each(function(e, i){
					//缓存侦听器
					var cu = A.one(e),
						evts = cu.data('events') || '';
					cu.data('events', evts ? evts += ',' + type : type);
					//添加
					A.event.add(e, type, handler, once, i);
				});
			}
		}
		return _;
	},
	//删除侦听器
	off : function(type){
		return this.each(function(e){
			A.event.remove(e, type);
			//清除事件列表
			var cu = A.one(e);
			cu.data('events', cu.data('events').replace(type, ''));
		});
	},
	//删除所有侦听器
	offAll : function(){
		return this.each(function(e){
			var _ = A.one(e);
			eh(_.data('events').split(','), function(ev){
				_.off(ev);
			});
		});
	},
	//绑定一次性事件
	once : function(type, handler){
		return this.on(type, handler, true);
	},
	//事件委派
	live : function(tg, evt, callback){
		var _ = this,
			node,
			cl;
		//如果目标元素有样式名
		if(hv(tg, '.')){
			var cls = tg.split('.');
			node = tg.indexOf('.') == 0 ? 'div' : cls[0];
			b(node, cls[1]);
		}else{
			b(tg);
		}
		function b(t, c){
			return _.on(evt, function(o){
				var e = o.currentTarget,
					is = c ? hs(e, c) : true;
				if(e.nodeName.toLowerCase() == t && is){
					callback.call(this, o);
				}
			});
		}
	},
	//模拟触发事件
	fire : function(evt){
		var i = isStr(evt);
		return this.each(function(e){
			if(i){
				eh(evt.split(','), function(ev){
					fire(e, ev);
				});
			}
		});
	},
	//设置动画
	fx : function(attr, conf, callback){
		var _ = this,
			qfx = _.animate,
			//预置若conf为数值类型时的完成回调函数
			fn = isNum(conf) ? function(){
				isFn(callback) && callback();
				erase();
			} : null,
			//创建动画对象
			fx = new A.Fx(_.$, attr, conf, fn);
		//重写完成回调函数
		if(!isNum(conf)){
			fx.complete = function(){
				isFn(conf.complete) && conf.complete();
				erase();
			}
		}
		//清除队列元素
		function erase(){
			//从动画队列中删除
			fx.destroy();
			qfx.shift();
			//如果动画队列中有未完成的则继续队列
			if(qfx.length){
				//重新设置样式后启动动画
				qfx[0].config().run();
			}
		}
		//加入队列
		qfx.push(fx);
		//如果动画队列中只有当前一个任务则执行当前任务
		qfx.length == 1 && fx.run();
		return _;
	},
	//渐显动画
	fadeIn : function(time, callback){
		var _ = this,
			at = tc(time, callback),
			//如果当前元素为隐藏状态
			opa = _.css('display') == 'none' ? 0 : _.css(OPAC);
		return _.show().css('opacity', opa).fx({opacity: [opa, 1]}, at.time, at.callback);
	},
	//渐隐动画
	fadeOut : function(time, callback){
		var _ = this,
			at = tc(time, callback),
			time = at.time,
			isShow = _.css('display') == 'none';
		if(!isShow){
			return _.show().fx({opacity: [isShow ? 0 : _.css(OPAC), 0]}, time, function(){
				//隐藏自身
				_.hide();
				//如果有回调函数则执行回调函数
				if(time){
					isNum(time) ? isFn(at.callback) && at.callback() : isFn(time.complete) && time.complete();
				}
			});
		}else{
			return _;
		}
	},
	//渐变到某种不透明度
	fadeTo : function(val, time, callback){
		var _ = this,
			at = tc(time, callback),
			opa = _.css('display') == 'none' ? 0 : _.css(OPAC);
		return _.css({ opacity : opa, display : 'block'}).fx({opacity: [opa, val]}, at.time, at.callback);
	},
	//添加拖放
	drag : function(params){
		dd.call(this, params);
		return this;
	}
});
//扩展节点类便捷方法
eh('click,dblclick,blur,focus,load,resize,scroll,mousedown,mouseup,mouseover,mouseout,mousemove,change,select,submit,keydown,keypress,keyup,input,transitionend'.split(','), function(e){
	A.Node.prototype[e] = function(fn){
		//如果传入回调则绑定事件，否则则模拟触发事件
		return isFn(fn) ? this.on(e, fn) : this.fire(e);
	}
});

/*-----  事件类 -----*/
A.add('Event', {
	init : function(target, type, handler, once, index){
		var _ = this;
		
		//获取文档边距
		var bmo = A.one(Doc.body).offset();
			
		//设置属性
		_.set(arguments.length == 1 && ob(target) ? target : {
			//绑定事件发生对象
			'target'  : target, 
			//事件类型
			'type'	  : type, 
			//是否是一次性事件
			'handler' : handler, 
			//回调函数
			'once'	  : once  || false, 
			//当前项在序列中的位置
			'index'	  : index || 0
		});
		//缓存回调函数为私有变量
		_._handler = function(o){
			//针对window对象特殊处理
			var _iw = iw(_.target) || _.target == Doc;
			_.set({
				//事件对象
				evt : o,
				//事件发生当前对象，一般在冒泡情况下使用
				currentTarget : o.target || o.srcElement,
				//鼠标距事件对象左边距
				x : _iw ? (Doc.documentElement.scrollLeft || Doc.body.scrollLeft) : (!o.offsetX && o.layerX ? o.layerX : o.offsetX),
				//鼠标距事件对象上边距
				y : _iw ? (Doc.documentElement.scrollTop || Doc.body.scrollTop) : (!o.offsetY && o.layerY ? o.layerY : o.offsetY),
				//鼠标相对于文档的左边距，加上滚动条坐标
				pageX : _iw ? 0 : (o.pageX || o.clientX + Dmt.scrollLeft) + bmo.x,
				//鼠标相对于文档的上边距，加上滚动条坐标
				pageY : _iw ? 0 : (o.pageY || o.clientY + Dmt.scrollTop) + bmo.y
			});
			//回调
			_.handler.call(_.target, _);
			//如果是一次性事件
			if(once){
				_.destroy();
			}
		};
		//
		var tg = _.target,
			type = _.type,
			handleTem = _._handler;
		
		//绑定事件
		if(tg.addEventListener){
			//转换css3动画完成事件
			type = type == 'transitionend' ? gte() : type;
			tg.addEventListener(type || type, handleTem, false)
		}else{
			//转换输入事件
			type = type == 'input' ? 'propertychange' : type;
			tg.attachEvent('on' + type || type, handleTem)
		}
		//加入序列
		A.stack.add('Event', _);
		return _;
	},
	//删除对象
	destroy : function(){
		var _ = this,
			tg = _.target,
			type = _.type,
			handleTem = _._handler;
		//解绑事件，删除变量
		tg.removeEventListener ? tg.removeEventListener(type, handleTem) : tg.detachEvent('on' + type, handleTem);
		A.stack.remove('Event', _);
	},
	//阻止冒泡
	stopPropagation : function(){
		var e = this.evt;
		e && e.stopPropagation ? e.stopPropagation() : e.cancelBubble = true;
		return this;
	},
	//阻止默认行为
	preventDefault : function(){
		var e = this.evt;
		e && e.preventDefault ? e.preventDefault() : e.returnValue = false;
		return this;
	}
});

/*----- 动画类 -----*/
//预置缓动效果
var easing = {
	'linear' : function(t, b, c, d){ return c * t / d + b; },
	'ease' : function(t, b, c, d){ return c * Math.sin(t / d * (Math.PI / 2)) + b; },
	'ease-in' : function(t, b, c, d){ return c * (t /= d) * t * t + b; },
	'ease-out' : function(t, b, c, d){ return c * ((t = t / d - 1) * t * t + 1) + b; },
	'ease-in-out' : function(t, b, c, d){ 
		if((t /= d / 2) < 1) return c / 2 * t * t * t + b;
		return c / 2 * ((t -= 2) * t * t + 2) + b;
	}
};

A.add('Fx', {
	//动画开始时回调
	start	 : empty,
	//动画结束时回调
	complete : empty,
	//缓动类型
	easing   : 'linear',
	//过渡时间
	duration : 600,
	//构造函数
	init : function(ele, attr, conf, callback){
		var _ = this;
			
		//如果传入的是时间
		if(isNum(conf)){
			//如果conf为数值类型则构建配置对象
			_.duration = parseInt(conf);
			//构建回调函数
			if(!A.isNull(callback)){
				_.complete = callback;
			}
		}
		
		//设置默认参数
		_.set(conf).set({
			//样式终值
			'getAttr' : attr,
			//动画对象
			'target' : mr(ele)
		});
		
		//加入到动画队列
		A.stack.add('Fx', _);
		
		//配置
		_.config();
	},
	//清除动画对象
	destroy : function(){
		var _ = this;
		clearTimeout(_.timer);
		A.stack.remove('Fx', _);
	},
	//计算动画样式范围
	config : function(){
		var _ = this;
		//样式集合
		_.attr = {};
		//存储各节点的样式集合中值集合，带集合结构的二位数组
		_.fromTo = [];
		var _fromTo = _.fromTo,
			_attr = _.attr;
		eh(_.target, function(e, m){
			//样式值集合
			var cls = {};
			//获取初始值
			for(var i in _.getAttr){
				//先将带'-'的样式名进行转化
				var n = cl(i),
					//终止值
					_v = _.getAttr[i],
					isOpa = i == OPAC;
				//设置
				_attr[n] = _v;
				//将字符串形式的赋值转为数值类型
				var __v = cs([e], Doc.all ? n : i);
				//如果是颜色值
				if(isStr(__v) && hv(__v, 'rgb')){
					__v = dh(__v);
					//转换rgba模式
					var _a = __v.match(rrga);
					if(_a){
						_a.shift();
						__v = 'rgb('+ _a.join(',') +')';
					}
					cls[n] = [__v, _v.colorRgb()];
				}else{
					cls[n] = isNum(_v) ? [(isOpa ? parseFloat(__v) : parseInt(__v)) || 0, isOpa ? _v : Math.round(_v)] : _v;
				}
			}
			_fromTo[m] = cls;
		});
		return _;
	},
	//执行
	run : function(attr){
		var _ = this,
			_target = _.target,
			_getAttr = _.getAttr;
		//如果传值
		if(ob(attr)){
			_.getAttr = attr;
			_.config().run();
			return;
		}
		if(_.timer){
			return;
		}
		var _time = +new Date();
		//启动
		ani(_, _time);
		//执行开始回调函数
		_.start();
		return _;
	}
});

/*----- Ajax数据交互类 -----*/
A.add('IO', {
	//构造函数
	init : function(params){
		var _ = this;
		//配置
		_.set({
			'url'		: '',
			'method'	: 'get',
			'data'		: {},
			'start'		: empty,
			'complete'  : empty,
			'error'		: empty,
			'async'		: true
		});
		//设置参数
		params && _.set(params);
		//创建XMLHttpRequest对象
		_.xhr = window.XMLHttpRequest ? new XMLHttpRequest() : new ActiveXObject('Microsoft.XMLHTTP');
		//加入队列
		A.stack.add('IO', _);
	},
	//析构函数
	destroy : function(){
		//从队列中删除
		A.stack.remove('IO', this);
	},
	//开始请求
	request : function(url, complete){
		var _ = this,
			xhr = _.xhr,
			method = _.method;
		//调用开始请求函数
		_.start();
		//重写请求地址和回调函数
		if(url){
			_.url = url;
		}
		if(complete){
			_.complete = complete;
		}
		//重写完成回调函数
		var _complete = function(){
			//先执行原生回调函数
			_.complete.call(_, xhr.responseText);
			_.destroy();
		};
		xhr.onreadystatechange = function(){
			if(xhr.readyState == 4){
				var _status = xhr.status;
				(_status >= 200 && _status < 300) || _status == 304 ? _complete() : _.error();
			}
		};
		xhr.open(method, _.url, _.async);
		if(method == 'post'){
			var data = _.data;
			xhr.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded');
			data && xhr.send(isStr(data) ? data : new A.Map(data).parse());
		}else{
			xhr.send(null);
		}
		return _;
	}
});

/*----- 界面类 -----*/
A.add('UI', {
	//实例化方式，默认为cmd命令式，标签式：tag
	initType : 'cmd',
	//渲染进的容器id
	renderTo : '',
	//UI布局内容
	content	: '',
	//自定义样式
	className : '',
	//默认尺寸
	width : AUTO,
	height : AUTO,
	display : true,
	//初始化
	onInit : empty,
	//构建完成
	onBuild : empty,
	//渲染完毕
	onRender : empty,
	//销毁时
	onDestroy : empty,
	//构造函数
	init : function(attrs){
		var _ = this;
		
		//配置
		attrs && _.set(attrs);
		
		_.onInit(attrs);
		
		//创建界面
		_.build();
		
		//添加到队列
		A.stack.add(_.model, _);
	},
	//析构函数
	destroy : function(){
		var _ = this;
		//删除前回调
		_.onDestroy();
		
		//删除DOM
		_.content = '';
		_.wrap.remove();
		
		//从队列中删除
		A.stack.remove(_.model, _);
	},
	//创建Dom
	build : function(){
		var _ = this,
			cla = 'A-ui-wrap',
			pClass = 'A-'+ _.model;
		
		//设置私有id
		_.set('id', pClass + '_' + id(_.model), true);
		
		//定义外部容器，为Node类型
		_.wrap = nd(A.build('div.' + cla + '.' + pClass + '#' + _.get('_id', true) + '{' + _.content + '}'));
		_.setWidth(_.width).setHeight(_.height);
		
		//初始化显示状态
		_[_.display ? 'show' : 'hide']();
				
		//构建后回调
		_.onBuild();
		
		return _;
	},
	//渲染组件
	render : function(id){
		var _ = this,
			id = id || _.renderTo,
			_initType = _.initType;
		
		//如果页面存在这个组件则先删除再重建
		A.one(_.get('_id', true)).remove();
		
		//如果是传统的命令实例化
		if(_initType == 'cmd'){
			//插入到文档中，如果不指定id则插入到文档尾部
			(id ? A.one(id) : nd(Doc.body)).append(_.wrap);
		}else 
		//如果是标签实例化则替换标签位置
		if(_initType == 'tag'){
			var tag = _.get('_tag', true);
			if(tag){
				tag.parentNode.replaceChild(_.wrap.$[0], tag);
			}
		}
		
		//渲染完回调
		setTimeout(function(){
			_.onRender();
		}, 20);
		
		return _;
	},
	//侦听事件
	on : function(name, callback){
		var _ = this;
		
		return _;
	},
	//设置高
	setWidth : function(val, callback){
		var _ = this;
		if(val){
			_.width = val;
			_.wrap.width(val);
		}
		//设置后回调
		isFn(callback) && callback();
		return _;
	},
	//设置宽
	setHeight : function(val, callback){
		var _ = this;
		if(val){
			_.height = val;
			_.wrap.height(val);
		}
		//设置后回调
		isFn(callback) && callback();
		return _;
	},
	//增加组件
	addChild : function(ele){
		this.wrap.append(ele.wrap || ele);
		_.build();
		return this;
	},
	//填充内容
	setContent : function(str){
		var _ = this;
		_.wrap.html(str);
		_.build();
		return _;
	},
	//显示
	show : function(){
		var _ = this;
		_.display = true;
		_.wrap.show();
		return _;
	},
	//隐藏
	hide : function(){
		var _ = this;
		_.display = false;
		_.wrap.hide();
		return _;
	}
});

/*----- JSON解析类 -----*/
var cx = /[\u0000\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g,
	escapable = /[\\\"\x00-\x1f\x7f-\x9f\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g,
	gap,
	indent,
	meta = {'\b': '\\b','\t': '\\t','\n': '\\n','\f': '\\f','\r': '\\r','"' : '\\"','\\': '\\\\'},
	rep;

//扩展原生对象的toJSON方法
Date.prototype.toJSON = function () {
	var _ = this;
	return isFinite(_.valueOf()) 
		? _.getUTCFullYear()	 + '-' + 
		  f(_.getUTCMonth() + 1) + '-' + 
		  f(_.getUTCDate())		 + 'T' + 
		  f(_.getUTCHours()) 	 + ':' + 
		  f(_.getUTCMinutes())	 + ':' + 
		  f(_.getUTCSeconds())	 + 'Z' 
		: null;
};
String.prototype.toJSON =
Number.prototype.toJSON =
Boolean.prototype.toJSON = function () {
	return this.valueOf();
};
A.add('JSON', {
	json : '',
	//构造
	init : function(json){
		this.json = json;
		A.stack.add('JSON', this);
	},
	//析构
	destroy : function(){
		this.json = null;
		A.stack.remove('JSON', this);
	},
	//解析json对象为字符串
	stringify : function(replacer, space){
		var i;
			gap = '';
			indent = isNum(space) ? en(' ', space) : (isStr(space) ? space : '');
		rep = replacer;
		if(replacer && !isFn(replacer) && (typeof replacer !== 'object' || !isNum(replacer.length))) {
			throw new Error('A.JSON.stringify');
		}
		return str('', {'': this.json});
	},
	//解析字符串为json对象
	parse : function(reviver){
		var j,
			text = String(this.json);
		cx.lastIndex = 0;
		if (cx.test(text)) {
			text = text.replace(cx, function (a) {
				return '\\u' + ('0000' + a.charCodeAt(0).toString(16)).slice(-4);
			});
		}
		if(/^[\],:{}\s]*$/.test(
			text.replace(/\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g, '@')
				.replace(/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g, ']')
				.replace(/(?:^|:|,)(?:\s*\[)+/g, ''))) {
			j = eval('(' + text + ')');
			return typeof reviver === 'function' ? walk({'': j}, '') : j;
		}
		throw new SyntaxError('JSON.parse');
	}
});

/*----- 微模版类 -----*/
A.add('Tpl', {
	//构造
	init : function(tpl){
		var conf;
		//参数集合
		if(ob(tpl)){
			conf = tpl;
		}else 
		//单个参数
		if(A.isStr(tpl)){
			conf = { tpl : tpl, str : false };
		}
		this.set(conf);
		A.stack.add('Tpl', this);
	},
	//析构
	destroy : function(){
		this.tpl = '';
		A.stack.remove('Tpl', this);
	},
	//解析输出
	parse : function(){
		var _ = this,
			str = bld(_.tpl.trim()),
			s;
		//如果输出字符串
		if(_.str){
			s = str;
		}else{
			var d = Doc.createElement('div'),
				c;
			d.innerHTML = str;
			c = d.children;
			//节点序列
			if(c.length > 1){
				s = c;
			}else
			//单节点
			if(c.length == 1){
				s = c[0];
			}
		}
		return s;
	}
});


/* ----------------------------------------------
 *
 * 功能函数部分
 * 基础功能、选择器及Node类处理、样式相关
 * 
 * ----------------------------------------------


/*---------------基础功能相关--------------*/
//设置属性集合基础方法
function _r(attr, obj){
	for(var i in attr){
		obj[i] = attr[i];
	}
}
//转换为数组
function ma(ar){
	return [].merge(ar);
}
//设置属性集合
function ar(attr, target){
	if(target.nodeName =='INPUT'){
		_r(attr, target)
	}else{
		for(var i in attr){
			i == CLSN ? target[CLSN] = attr[i] : target.setAttribute(i, attr[i]);
		}
	}
}
//转换数组
function mr(o){
	return o.length ? o : [o];
}
//生成随机的ID
function id(type){
	var co = A.stack.queue[type];
	return co && co.length ? co.last().id + 1 : 0;
}
//生成随机数，len为生成的长度，默认为10位，isNum表示是否为纯数字，默认为带字母
function rd(len, isNum){
	var ram = Math.random(),
		len = len || 10;
	return ram.toString(isNum ? 16 : 10).substring(2, len + 2);
}
//扩展原型链对象
function ip(d, k){
	if(typeof d == 'string' && arguments.length == 2){
		this.prototype[d] = k;
	}else{
		_r(d, this.prototype);
	}
}
//循环数组集合
function eh(o, callback){
	if(o && o.length){
		for(var i = 0, l = o.length; i < l; i ++){
			if(callback.call(o, o[i], i) === false){
				break;
			}
		}
	}
};
//检测字符串包含
function hv(e, v){
	return e.indexOf(v) > -1;
}
//是否为集合对象
function ob(obj){
	return typeof obj == 'object' && !obj.length;
}
//遍历哈希表获取值
function kh(the, val, is){
	var tg = the.hash;
	for(var i in tg){
		if(tg[i] == val){
			return is ? true : i;
		}
	}
	return is ? false : '';
}
//如果是窗口对象
function iw(o){
	return !!o && o.parent == window;
}
//去中间空格
function dh(s){
	return s.replace(/\s+/g, '');
}

/*---------------JSON类处理相关--------------*/
function f(n){
	return n < 10 ? '0' + n : n;
}
function walk(holder, key){
	var k, v, value = holder[key];
	if (value && typeof value === 'object') {
		for (k in value) {
			if (Object.prototype.hasOwnProperty.call(value, k)) {
				v = walk(value, k);
				if(v !== undefined) {
					value[k] = v;
				}else{
					delete value[k];
				}
			}
		}
	}
	return reviver.call(holder, key, value);
}
function quote(string) {
	escapable.lastIndex = 0;
	return escapable.test(string) ? '"' + string.replace(escapable, function (a) {
		var c = meta[a];
		return typeof c === 'string'
			? c
			: '\\u' + ('0000' + a.charCodeAt(0).toString(16)).slice(-4);
	}) + '"' : '"' + string + '"';
}
function str(key, holder) {
	var i,
		k,
		v,
		length,
		mind = gap,
		partial,
		value = holder[key];
	if(value && typeof value === 'object' && typeof value.toJSON === 'function') {
		value = value.toJSON(key);
	}
	if(typeof rep === 'function') {
		value = rep.call(holder, key, value);
	}
	//
	switch (typeof value) {
	case 'string':
		return quote(value);
	case 'number':
		return isFinite(value) ? String(value) : 'null';
	case 'boolean':
	case 'null':
		return String(value);
	case 'object':
		if (!value) {
			return 'null';
		}
		gap += indent;
		partial = [];
		if (Object.prototype.toString.apply(value) === '[object Array]') {
			length = value.length;
			for(i = 0; i < length; i += 1) {
				partial[i] = str(i, value) || 'null';
			}
			v = partial.length === 0 ? '[]' : gap ? '[\n' + gap + partial.join(',\n' + gap) + '\n' + mind + ']' : '[' + partial.join(',') + ']';
			gap = mind;
			return v;
		}
		if(rep && typeof rep === 'object') {
			length = rep.length;
			for(i = 0; i < length; i += 1) {
				if(typeof rep[i] === 'string') {
					k = rep[i];
					v = str(k, value);
					if(v) {
						partial.push(quote(k) + (gap ? ': ' : ':') + v);
					}
				}
			}
		}else{
			for(k in value){
				if(Object.prototype.hasOwnProperty.call(value, k)) {
					v = str(k, value);
					if(v){
						partial.push(quote(k) + (gap ? ': ' : ':') + v);
					}
				}
			}
		}
		v = partial.length === 0 ? '{}' : gap ? '{\n' + gap + partial.join(',\n' + gap) + '\n' + mind + '}' : '{' + partial.join(',') + '}';
		gap = mind;
		return v;
	}
}

/*-------------选择器功能函数--------------*/
//相关正则
var rv = /{(.*?)\}/,
	rvg = /{(.*?)\}/g,
	rw = /\((.+)\)/,
	rwg = /\((.+)\)/g,
	re = /\((.+)\)\*(\d+)/,
	reg = /\((.+)\)\*(\d+)/g,
	rh = /\*(\d+)/g,
	r1 = /{c}/g,
	r2 = /{i}/g,
	r3 = /{p}/g,
	r4 = /{v}/g,
	ra = /\[(\w+=.*?)\]/g,
	rcl = /\.([\w$_-]+)/g,
	ri = /\#([\w$_-]+)/g;
//选择器主函数
function sl(str){
	//存储选择器获取DOM元素总序列
	var tArray = [];
	//如果选择器是字符串
	if(A.isStr(str)){
		//去除两边空格
		var str = str.trim();
		//如果是标准浏览器则用querySelector方法
		if(isQuery){
			tArray = Doc.querySelectorAll(str);
		}else{
			//将查询字符串转换为一个查询序列
			var selArray = str.split(','),
				//定义堆栈,临时存放DOM层级元素
				pushStack = [];
			//逐个查找
			selArray.each(function(c){
				//如果是模糊查询
				if(hv(c, ' ')){
					var firTag = c.split(' ')[0],
						othTag = c.replace(firTag, '').trim(),
						//获取首层
						_arr = hv(firTag, '>') ? fil('', firTag) : fit('', firTag);
					//获取剩下层级
					pushStack = fd(_arr, othTag);
				}else 
				//如果是逐级查询
				if(hv(c, '>')){
					pushStack = fil('', c);
				//如果是单标签查询	
				}else{
					pushStack = fit('', c);
				}
				//把当前查询到的DOM序列合并到总序列中
				tArray = tArray.merge(pushStack);
			});
		}
	}else if(A.isEle(str) || str.length){
		tArray = mr(str);
	}
	return tArray;
}
//查询子孙层级节点
function fd(obj, str){
	if(obj.length){
		var _arr = [],
			//去除两边空格
			str = str.trim();
		//标准浏览器的查询
		if(isQuery){
			obj.each(function(o){
				_arr = _arr.merge(o.querySelectorAll(str));
			});
			stack = _arr;
		}else{
			//如果是模糊层级查询
			if(hv(str, ' ')){
				var tags = str.split(' '),
					stack = [];
				//遍历
				obj.each(function(o){
					//获取模糊层级
					tags.each(function(ob, i){
						//获取首标签
						var firTag = ft(ob);
						//如果是第一层级
						if(i == 0){
							var _tf = gtg(o, firTag);
							_arr = hv(ob, '>') ? fil(_tf, ob) : fit(_tf, ob);
						}else{
							//如果是第二层级则中第一层返回的结果中过滤
							var _oo = [];
							eh(_arr, function(oo){
								_oo = _oo.merge(gtg(oo, firTag));
							});
							_arr = hv(ob, '>') ? fil(_oo, ob) : fit(_oo, ob);
						}
					});	
				});
				stack = _arr;
			//如果不是模糊层级查询
			}else{
				var firTag = ft(str);
				//由首层查询到的结果模糊查询首位标签序列
				eh(obj, function(o){
					_arr = _arr.merge(gtg(o, firTag));
				});
				stack = hv(str, '>') ? fil(_arr, str) : fit(_arr, str);
			}
		}
		return stack;
	}
}
//获取查询字符串首位元素标签
function ft(tags){
	var r = tags.match(rf);
	return r ? r[0] : tags;
}
//过滤混合标签
function fit(obj, str){
	//提取标签
	var _t = str.replace(rcl, '').replace(ra, ''),
		_o = [];
	//如果不是第一层模糊查询
	if(obj){
		//筛选obj
		_o = ma(obj).filter(function(e){
			return e.nodeName.toLowerCase() == _t;
		});
		//
		var _f = str.match(rcl),
			_a = str.match(ra);
		//匹配样式
		if(_f){
			_o = fic(_o, _f.join(',').replace(/\./g, ''));
		}
		//匹配属性
		if(_a){
			_a[0].replace(ra, function(m, n){
				_o = fia(_o, n);
			});
		}
	//如果是第一层查询
	}else{
		//首级id，此时则忽略样式及属性查询参数
		if(str.match(ri)){
			_t = _t.replace(ri, function(m, n){
				var _n = Doc.getElementById(n);
				if(_n) _o = [_n];
				return '';
			});
		}else{
			_o = fit(ma(tg(_t || 'div')), str);
		}
	}
	return _o;
}
//过滤标签子集
function fis(obj, str){
	var isNum = A.isNum(str),
		_ooo = [],
		_o = [];
	//获取obj所有子项
	eh(obj, function(e){
		if(isNum){
			_ooo.push(e.children[str]);
		}else{
			eh(e.children, function(n){
				_o.push(n);
			});
		}
	});
	if(isNum){
		return _ooo;
	}
	//返回过滤后DOM，如果有查询字符串则返回过滤后的
	return str ? fit(_o, str) : _o;
}
//过滤标签样式
function fic(obj, str){
	//多重样式查询
	var _cls = str.split(','),
		_o = [];
	//遍历查找包含样式的DOM
	eh(obj, function(e){
		_cls.some(function(o){
			return hs(e, o);
		}) && _o.push(e);
	});
	return _o;
}
//过滤标签属性
function fia(obj, str){
	//获取属性字符串
	var	attr = str.split('='),
		atr0 = attr[0],
		atr1 = attr[1],
		_o = [];
	//如果要处理的集合有子项
	eh(obj, function(e){
		e.getAttribute(atr0) == atr1 && _o.push(e);
	});
	return _o;
}
//过滤标签层级
function fil(obj, str){
	var _deep = str.split('>'),
		//获取根层级
		_puk = fit(obj, _deep[0]);
	//从第二层逐层查找
	for(var x = 1,y = _deep.length; x < y; x ++){
		_puk = fis(_puk, _deep[x]);
	}
	return _puk;
}

/*---------------微模版引擎函数部分-----------------*/
//构建模版主函数
function bld(tags){
	var s = '';
	//先转义内容
	if(rv.test(tags)){
		tags = tags.replace(rvg, function(m, n){
			return '{' + n.replace(/\</g, '%3C').replace(/\>/g, '%3E').replace(/\+/g, '%!%') + '}';
		});
	}
	//如果有层级
	if(hv(tags, '>')){
		//如果有层级
		var _ar = tags.split('>'),
			i = _ar.length - 1;
		while(i > 0){
			_ar[i-1] = _ar[i-1] + '{'+ t(_ar[i]) +'}';
			s = t(_ar[i-1]);
			i --;
		}
	}else{
		s += t(tags);
	}
	//
	return s.replace(/%3C/g, '<').replace(/%3E/g, '>').replace(/%!%/g, '+');
}
//模版分层级
function t(p){
	var s = '';
	//循环
	if(re.test(p)){
		s = p.replace(reg, function(m, n, j){
			return en(tp(n), j);
		});
	}else 
	//包裹
	if(rw.test(p)){
		s = p.replace(rwg, function(m, n){
			return tp(n);
		});
	}
	//其他
	else{
		s = tp(p);
	}
	return s;
}
//分组模版
function tp(s){
	var o = '';
	if(hv(s, '+')){
		eh(s.split('+'), function(e){
			o += tt(e);
		});
	}else{
		o += tt(s);
	}
	return o;
}
//解析模版内容
function tt(s){
	var tgs = s,
		_rt = s.match(rf);
	//获取首位标签
	if(_rt){
		var t = _rt[0],
			//检测是否有标签循环
			tag = '<'+ t +'{c}{i}{p}>{v}</'+ t +'>';
		
		//如果有值
		if(rv.test(s)){
			//简化菜单
			tgs = tgs.replace(rvg, '');
			//值
			s = s.replace(rvg, function(m, n){
				tag = tag.replace(r4, n);
				return '';
			});
		}
		//如果有属性
		if(tgs.match(ra)){
			//简化菜单
			tgs = tgs.replace(ra, '');
			//
			s = s.replace(ra, function(m, n){
				if(hv(n, '=')){
					var _ar = n.split('=');
					tag = tag.replace(r3, '{p} '+ _ar[0] +'=\"' + _ar[1] + '\"');
				}
				return '';
			});
		}
		//多样式
		if(tgs.match(rcl)){
			tag = tag.replace(r1, ' class=\"' + tgs.match(rcl).join(' ').replace(/\./g, '') + '\"');
		}
		//如果有id
		if(tgs.match(ri)){
			s = s.replace(ri, function(m, n){
				tag = tag.replace(r2, ' id=\"' + n + '\"');
				return '';
			});
		}
		//如果有标签循环
		var _j = s.match(rh);
		if(_j){
			var j = _j[0].replace(rh, function(o, p){
				return p;
			});
			tag = en(tag, j.int());
		}
		//
		return tag.replace(r1, '').replace(r2, '').replace(r3, '').replace(r4, '');
	}
	return s;
}
//检测转换模版格式
function ttp(s, is){
	return rt.test(s) ? A.build(s.replace(rt, function(m, n){
		return n;
	}), is) : s;
}

/*---------------Node处理函数部分-----------------*/

//返回由标签查询的节点
function tg(t){
	return gtg(Doc, t);
}
//获取子孙标签
function gtg(o, t){
	return o.getElementsByTagName(t);
}
//返回一个节点对象
function nd(o){
	return o ? new A.Node(o) : new A.Node();
}
//转换节点类型
function tr(e){
	return isNode(e) ? e.$ : mr(e);
}
//筛选 prev & next 元素
function dr(o, dir, isSingle, s){
	var _o = [],
		_d;
	o.each(function(oo){
		oo = oo[dir];
		while(oo){
			if(oo.nodeType == 1){
				if(isSingle){ 
					_d = nd([oo]);
					break;
				}
				_o.push(oo);
			}
			oo = oo[dir];
		}
	});
	return _d || nd(s ? fit(_o, s) : _o);
}
//设置属性
function st(o, type, val, the){
	if(!A.isNull(val)){
		eh(o, function(e){
			e[type] = val;
		});
		return the;
	}else{
		return o[0] ? o[0][type] : '';
	}
}
//是否显示，参数若为true为显示，为false则隐藏
function dp(o, iShow, the){
	var val = iShow ? 'block' : 'none';
	eh(o, function(e){
		e.style.display = val;
	});
	return the;
}
//过滤奇偶
function eo(the, is){
	var e = [],
		o = [];
	the.each(function(oo, i){
		i % 2 == 0 ? o.push(oo) : e.push(oo);
	});
	return nd(is ? e : o);
}
//获取转换后的time，callback参数
function tc(time, callback){
	var callback = callback ? callback : A.isFn(time) ? time : null,
		time = time && A.isNum(time) ? time : 600;
	return { 'time' : time, 'callback' : callback };
}
//次数循环
function en(_, n){
	var s = '',
		n = n || 1;
	for(var i = 0; i < n; i ++){
		s += _.replace(/\$/g, i);
	}
	return s;
}
function fire(e, v){
	// 标准浏览器使用dispatchEvent方法  
	if(Doc.createEvent){
		var ev = document.createEvent('HTMLEvents');
		ev.initEvent(v, true, true);  
		e.dispatchEvent(ev);
	}else
	// IE浏览器支持fireEvent方法 
	if(Doc.createEventObject){
		e.fireEvent('on' + v);
	}
}

/*----------------样式相关----------------*/
var fo = 'webkitT MozT t'.split(' '),
	colors = 'color backgroundColor borderColor';
//设置宽高
function wh(o, type, val, the){
	if(val != undefined){
		val = A.isStr(val) ? (val.toLowerCase() == AUTO ? AUTO : val.int() + 'px') : val + 'px';
		eh(o, function(e){
			e.style[type] = val;
		});
		return the;
	}else{
		return the.css(type);
	}
}
//获取位置
function po(o){
	if(o){
		var left,
			top,
			Bo = Doc.body;
		if(o.getBoundingClientRect){
			var el = o.getBoundingClientRect(),
				st = Dmt.scrollTop || Bo.scrollTop,
				sl = Dmt.scrollLeft || Bo.scrollLeft;
			left = sl + el.left;
			top = st + el.top;
		}else{
			left = o.offsetLeft;
			top = o.offsetTop;
			while(o = o.offsetParent){
				left += o.offsetLeft;
				top += o.offsetTop;
			}
		}
		return { x : left, y : top };
	}else{
		return {x : null, y : null};
	}
}
//操作样式
function cs(obj, val, the){
	//获取样式
	if(A.isStr(val)){
		var fir = obj[0];
		//优先处理宽、高、透明度属性
		if(hv('width height opacity', val)){
			if(fir){
				//如果是window对象
				var _iw = iw(obj[0]),
					dc = gs(obj, val),
					firStyle = fir.style;
				switch(val){
					case 'width':
						if(_iw){
							return Dmt.clientWidth;
						}
						return dc == AUTO ? fir.offsetWidth - os(obj, 'left', 'right') : parseInt(dc);
					case 'height':
						if(_iw){
							return Dmt.clientHeight;
						}
						return dc == AUTO ? fir.offsetHeight - os(obj, 'top', 'bottom') : parseInt(dc);
					case OPAC:
						var _fo = firStyle.filter.match(ro);
						return Doc.all && fir && fir.filters
							? (_fo ? _fo[0].replace(/\)/, '').split('=')[1]/100 : 1)
							: (firStyle[OPAC] == '' ? 1 : parseFloat(firStyle[OPAC]));
				}
			}
		}else{
			var _v = gs(obj, val);
			//如果是颜色值则转成rgb输出
			return hv(colors, val.toLowerCase()) ? _v.colorRgb() : _v;
		}
	//设置样式
	}else{
		eh(obj, function(o){
			if(o.style){
				for(var i in val){
					var value = cl(i),
						cu = val[i];
					if(i == OPAC){
						o.filters ? (o.style.filter = 'alpha(opacity=' + (cu * 100) + ')') : (o.style[OPAC] = cu);
					}else{
						//如果是转换
						value = value == 'transition' ? gtr() : value;
						o.style[value] = A.isNum(cu) ? cu + 'px' : cu;
					}
					if(isIE6){
						o.style.zoom = 1;
					}
				}
			}
		});
		return the;
	}
}
//获取默认样式
function gs(obj, val){
	var fir = obj[0];
	return fir && fir.nodeName ? (Doc.all && cl(val) ? fir.currentStyle[cl(val)] : Doc.defaultView.getComputedStyle(fir, null).getPropertyValue(val)) : '';
}
//附加样式表
function dc(url){
	//检查有没有相同的css文件
	var ag = ma(links).get(function(e){
		return e.href == url;
	});
	if(url && !ag.length){
		var l = Doc.createElement('link');
		l.rel = 'stylesheet';
		l.href = url;
		head.appendChild(l);
	}
}
//获取元素外围尺寸
function os(o, size1, size2){
	var s = 0;
	('border-'+ size1 +'-width border-'+ size2 +'-width padding-'+ size1 +' padding-'+ size2).split(' ').each(function(e){
		if(o){
			var val = cs(o, e);
			s += parseInt(val) || 0;
		}
	});
	return s;
}
//包含样式名
function hs(e, c){
	if(e){
		return hv((' ' + e[CLSN] + ' '), ' ' + c.trim() + ' ');
	}
}
//添加样式
function ac(e, c){
	!hs(e, c) && (e[CLSN] += ' ' + c);
}
//删除样式
function rc(e, c){
	e[CLSN] = e[CLSN].replace(c, '');
}
//启动动画
function ani(_, _time){
	_.timer = setTimeout(function(){
		step(_, _time);
	}, 20);
}
//动画步进
function step(_, _time){
	var tg = _.target,
		_attr = _.attr,
		_fromTo = _.fromTo,
		curr = [],
		time = +new Date(),
		//缓动函数
		easingFn = easing[_.easing],
		cTime;
	if (time < _time + _.duration){
		cTime = time - _time;
		//计算当前样式步进值
		eh(tg, function(e, m){
			var cls = {};
			for(var i in _attr){
				//动画范围
				var icurr = _fromTo[m][i];
				//计算颜色值
				if(hv(colors, i)){
					var c1 = dh(icurr[0]).match(rrg),
						c2 = dh(icurr[1]).match(rrg),
						_cs = [];
					if(c1 && c2){
						c1.shift();
						c2.shift();
						eh(c1, function(o, n){
							var _bw = parseInt(c2[n]) - parseInt(o);
							//如果初始值等于终值
							if(_bw == 0){
								_cs.push(o);
							}else{
								var _v  = (easingFn(cTime, o, Math.abs(_bw), _.duration)).int();
								_cs.push(_bw > 0 ? _v + o.int() : Math.abs(_v - o));
							}
						});
						cls[i] = 'rgb('+ _cs.join(',') +')';
					}
				}else{
					cls[i] = easingFn(cTime, icurr[0], icurr[1] - icurr[0], _.duration);
				}
			}
			curr[m] = cls;
		});
		ani(_, _time);
	} else {
		//动画执行完成
		_.complete.delay(10);
		eh(tg, function(e, m){
			var cls = {};
			for(var i in _attr){
				cls[i] = _fromTo[m][i][1];
			}
			curr[m] = cls;
		});
		_.destroy();
	}
	//设置最终样式
	eh(tg, function(e, m){
		cs([e], curr[m], _);
		//如果不透明值为1在ie下删除filter样式
		if(e.filters && hv(e.style.filter, 'opacity=100')){
			e.style.removeAttribute('filter');
		}
	});
}
//获取css动画执行完毕的回调事件
function gte(){
	var t,
		transitions = {  
		  'transition' : 'transitionend',  
		  'OTransition' : 'oTransitionEnd',  
		  'MozTransition' : 'transitionend',  
		  'WebkitTransition' : 'webkitTransitionEnd',  
		  'MsTransition':'msTransitionEnd'  
		};
	//
	for(var i in transitions){  
		if(antag.style[i] !== undefined){  
			t = transitions[i];
			break;
		}  
	}
	//惰性函数
	gte = function(){
		return t;
	};
	return gte();
}
//转换css3过渡属性
function gtr(){
	var t;
	eh(fo, function(e){
		if(antag.style[e + 'ransition'] !== undefined){  
			t = e + 'ransition';
			return false;
		}
	});
	//惰性函数
	gtr = function(){
		return t;
	};
	return gtr();
}
//清除样式属性中的'-'，转换成驼峰式命名
function cl(i){
	if(hv(i, '-')){
		i.split('-').each(function(e, n){
			n == 0 ? i = e : i += e.charAt(0).toUpperCase() + e.substr(1);
		});
	}
	return i;
}
//拖放操作
function dd(params){
	var _ = this,
		move = 'mousemove',
		Bo = Doc.body,
		$Dmt = A.one(Dmt),
		//指定拖动手柄
		isHandle = false,
		range = [],
		handler = _,
		start = empty,
		dragging = empty,
		complete = empty,
		dir = '',
		ow,
		oh,
		ml,
		mt,
		cevt;
	//处理参数
	if(params){
		//是否指定拖动手柄
		isHandle = !!params.handler;
		//确定拖动手柄，如果没有指定则为拖动对象本身
		handler = isHandle ? _.find(params.handler) : _;
		range = params.range;
		start = params.start || empty;
		dragging = params.dragging || empty;
		complete = params.complete || empty;
		//方向
		dir = params.dir || '';
	}
	//
	_.each(function(e, i){
		
		//绑定鼠标按下事件
		A.one(e).mousedown(function(ev){
			//顶级事件对象
			cevt = ev;
				//作用对象
			var o = ev.currentTarget,
				//父级
				parent = e.parentNode,
				//父级是否相对或绝对定位
				isPos = hv('absolute relative', cs([parent], 'position')),
				//如果父级为整个文档区域
				isFull = parent == Bo,
				//父级尺寸
				pw = isFull ? Math.max(Bo.scrollWidth, Dmt.scrollWidth) : parent.scrollWidth,
				ph = isFull ? Math.max(Bo.scrollHeight, Dmt.scrollHeight) : parent.scrollHeight,
				//事件发生的当前对象坐标
				posT = po(o),
				//顶级目标坐标
				posW = po(e),
				//父级坐标
				posP = po(o.parentNode),
				//拖动手柄
				cu = isHandle ? o : handler.list(0);
				
			//如果如果当前对象为拖动手柄则执行拖动绑定
			if(hv(handler.$, cu)){
				//父级是否绝对定位，记录鼠标相对目标移动对象坐标，如果父级元素为绝对定位时计算当前对象与父级对象的偏移值
				if(isPos){
					//获取拖动对象的尺寸
					ow = o.offsetWidth;
					oh = o.offsetHeight;
					ml = posP.x + ev.x;
					mt = posP.y + ev.y;
				}else{
					//获取拖动对象的尺寸
					ow = e.offsetWidth;
					oh = e.offsetHeight;
					ml = posT.x - posW.x + ev.x;
					mt = posT.y - posW.y + ev.y;
				}
				//如果拖动范围为父级对象
				if(range == 'parent'){
					var psX = posP.x,
						psY = posP.y;
					//父级是绝对定位时另行处理
					range = isPos 
						? [0, pw - ow, 0, ph - oh]
						: (isHandle ? [psX,  pw - ow, psY, ph - ow] : [psX,  pw - ow, psY, ph - oh]);
				}
				//执行开始回调函数
				start.call(ev);
				//取消页面选中
				Bo.onselectstart = function(){ return false };
				//根据方向确定拖动行为
				if(dir == 'x'){
					$Dmt.on(move, function(evt){
						var lf = evt.pageX - ml;
						sp('left', lf, e);
						dragging.call(ev, lf);
					});
				}else if(dir == 'y'){
					$Dmt.on(move, function(evt){
						var tp = evt.pageY - mt;
						sp('top', tp, e);
						dragging.call(ev, tp);
					});
				}else{
					$Dmt.on(move, function(evt){
						var lf = evt.pageX - ml,
							tp = evt.pageY - mt;
						sp('left', lf, e);
						range ? tp >= range[2] && tp <= range[3] && (e.style.top = tp + 'px') : e.style.top = tp + 'px';
						//拖动中的回调
						dragging.call(ev, {'x' : lf, 'y' : tp});
					});
				}
			}
		});
	});
	//鼠标弹起时清除拖动
	$Dmt.on('mouseup', function(evt){
		ml = 0;
		mt = 0;
		Bo.onselectstart = null;
		//清除文档鼠标划过事件
		$Dmt.off(move);
		//完成回调
		complete.call(cevt);
	}, 0, i);
	//设置元素坐标 
	function sp(dir, type, e){
		range ? type >= range[0] && type <= range[1] && (e.style[dir] = type + 'px') : e.style[dir] = type + 'px';
	}
}

//公开主类
Win[_A]  = A;

//增加主类的便捷访问
Win.A  = Win.A  || A;

//初始化时扫描组件标签
A.ready(function(){
	A.scan();
});

})('Ant', window, document);